Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@tests/CodexSessionManager.App.Tests/MainWindowCoverageTests.cs`:
- Around line 194-195: The test is trying to reflect a non-existent property
CurrentSearchCancellationTokenSource on MainWindow which will cause a runtime
failure; update the test to reflect the existing private field instead or add
the property to production: either change the test's
CurrentSearchCancellationTokenSourceProperty to use
typeof(MainWindow).GetField("_searchCts", BindingFlags.Instance |
BindingFlags.NonPublic) and update references to read/write that FieldInfo, or
implement a new internal/private property CurrentSearchCancellationTokenSource
on MainWindow that wraps the existing _searchCts (used by BeginSearchToken() and
DisposeSearchCancellation()) so the reflection call succeeds.
- Around line 68-80: The test is looking up a non-existent one-parameter
overload (DescribeSqlitePath(string)) which causes a Sequence contains no
matching element error; remove the DescribeSqlitePathSingleArgumentMethod lookup
and instead reuse the existing DescribeSqlitePathMethod (the two-parameter
method) when invoking it from tests, passing the second optional parameter
explicitly (e.g., null or a FileInfo-producing delegate) so the reflection call
matches the actual signature DescribeSqlitePath(string, Func<string,
FileInfo>?).

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@src/CodexSessionManager.App/MainWindow.SessionOperations.cs`:
- Around line 140-145: The code snapshots searchToken into a bool
(searchCanceled) before the UI dispatcher hop and calls repository methods with
CancellationToken.None, which allows stale searches to continue and their
results to overwrite newer ones; change the flow to honor the original
CancellationToken: pass the real searchToken into repository.ListSessionsAsync
(not CancellationToken.None), remove the pre-dispatch snapshot, and after each
await (both repository call and RunOnUiThreadAsync) explicitly check
searchToken.IsCancellationRequested (or call
searchToken.ThrowIfCancellationRequested) and abort applying results if
cancelled so that ListSessionsAsync, IsSearchCanceled usage, and the UI update
in RunOnUiThreadAsync all respect cancellation.

In `@src/CodexSessionManager.Storage/Maintenance/MaintenanceExecutor.cs`:
- Around line 41-49: The current logic in ValidateTypedConfirmation inverts the
RequiresTypedConfirmation check and wrongly throws for previews that explicitly
skip typed confirmation; change the flow so that you only enforce and validate
typedConfirmation when preview.RequiresTypedConfirmation is true: if
RequiresTypedConfirmation is true and typedConfirmation is null/whitespace,
throw the "Typed confirmation is required." InvalidOperationException, and only
when RequiresTypedConfirmation is true also compare
preview.RequiredTypedConfirmation to typedConfirmation using
StringComparison.Ordinal and throw when they don't match; leave previews with
RequiresTypedConfirmation == false untouched.

In `@src/CodexSessionManager.Storage/Parsing/SessionJsonlParser.cs`:
- Around line 212-221: The code calls textElement.GetString() without validating
the JSON token type, which can throw if "text" is not a string; update the
parsing in the block that uses TryGetPropertyValue(contentItem, "text", out var
textElement) to first check that textElement.ValueKind is JsonValueKind.String
(return false if not), then call GetString() into contentText — follow the same
pattern used in TryExtractCommand to guard against non-string JSON values before
using GetString().

---

Outside diff comments:
In `@src/CodexSessionManager.App/MainWindow.xaml.cs`:
- Around line 330-333: The early-return guard currently checks both
_currentMaintenancePreview and _maintenanceExecutor, hiding executor-init
failures; change the guard in the Execute button handler (the method referencing
_currentMaintenancePreview and _maintenanceExecutor / MaintenanceRunner) to only
return when _currentMaintenancePreview is null so that a null
_maintenanceExecutor is not silently ignored and its failure can surface (or be
handled centrally) instead of turning the click into a no-op.

In `@src/CodexSessionManager.Storage/Indexing/SessionCatalogRepository.cs`:
- Around line 421-438: The PreferredCopy may be synthesized and not present in
the PhysicalCopies list, causing a mismatch; in SessionCatalogRepository when
building the IndexedLogicalSession (sessions.Add call) ensure the PhysicalCopies
collection always contains the selected preferredCopy: either append/prepend the
preferredCopy to existingCopies when its FilePath is not present (compare by
FilePath) or construct a new list containing existingCopies plus preferredCopy
when needed, and pass that list into the IndexedLogicalSession constructor so
PreferredCopy and PhysicalCopies stay aligned.

---

Nitpick comments:
In `@src/CodexSessionManager.Storage/Parsing/SessionJsonlParser.cs`:
- Around line 24-25: The variable normalizedFilePath in SessionJsonlParser.cs is
misleading because no normalization occurs; either perform real normalization
(e.g., replace the assignment with normalizedFilePath =
Path.GetFullPath(filePath) or use Path.GetFullPath/Path.GetFullPathAsync as
appropriate and handle exceptions) or rename the variable to a clear name like
inputFilePath; update the subsequent usage (the File.ReadAllLinesAsync call) to
use the chosen variable name and add any necessary using for System.IO if you
opt to normalize.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@src/CodexSessionManager.App/MainWindow.xaml.cs`:
- Around line 90-100: Process.Start(startInfo) returns a Process that owns
native handles and is currently discarded causing resource leaks; capture the
returned Process (e.g., startedProcess) from the call to
Process.Start(startInfo) and ensure it is disposed immediately after use (either
wrap in a using/using var or call Dispose in a finally block) so the native
handles are released; update the block that builds startInfo and iterates
processArguments to store and dispose the Process instance instead of dropping
it.

In `@src/CodexSessionManager.Storage/Discovery/SessionDiscoveryService.cs`:
- Around line 35-57: The backup branch fails for relative roots like
"sessions_backup" because the EndsWith check expects a leading directory
separator; update the condition in the SessionStoreKind.Backup branch (where
normalizedRoot and normalizedBackupWorkspaceRoot are used and KnownSessionStore
is returned) to also detect a bare final segment "sessions_backup"—for example,
replace or augment the EndsWith check with a guard using
Path.GetFileName(normalizedRoot).Equals("sessions_backup",
StringComparison.OrdinalIgnoreCase) so both absolute ".../sessions_backup" and
relative "sessions_backup" correctly return the KnownSessionStore with
normalizedBackupWorkspaceRoot and the proper session_index.jsonl path.

In `@tests/CodexSessionManager.App.Tests/MainWindowActionCoverageTests.cs`:
- Around line 29-71: The tests create a MainWindow instance (variable window)
but never close it; update each affected test (e.g.,
ExternalActionButtons_use_wrappers and the other two similar tests) to call
window?.Close() in the finally block before calling DeleteDirectory(root) so the
window is always disposed even on assertion failures; ensure you reference the
same local variable name "window" and use a null-safe call (window?.Close()) to
avoid throwing if construction failed.

In `@tests/CodexSessionManager.App.Tests/MainWindowMaintenanceCoverageTests.cs`:
- Around line 23-68: Each async maintenance test that constructs a MainWindow
(e.g., BuildPreview_and_execute_maintenance_paths_update_uiAsync and the other
listed test methods) must deterministically close the window in the finally
block to trigger the Closed event handler and ReleaseSearchCancellationState();
update each finally block to call window?.Close() (or check for non-null and
call Close()) before cleaning up directories so the window is always closed even
on failures.

In `@tests/CodexSessionManager.App.Tests/MainWindowPrivateFlowCoverageTests.cs`:
- Around line 58-66: The polling loop that checks
GetNamedField<TextBlock>(window, "StatusTextBlock").Text is too aggressive
(20×10ms) and flakes on CI; extend the wait and reduce polling frequency by
replacing the for-loop with a loop that polls up to ~5 seconds (e.g., await
Task.Delay(50) per iteration with ~100 attempts) so dispatcher-scheduled UI
updates have time to run — keep the same check against "Failed action: boom" and
break when found, using the same GetNamedField<TextBlock> call and the same
"StatusTextBlock" identifier.

In `@tests/CodexSessionManager.Storage.Tests/StorageGuardClauseTests.cs`:
- Around line 340-356: The test helper AssertInvalidMoveTargetPath currently
expects InvalidOperationException from invoking MoveTargetsMethod but the new
BuildDestinationPath guard throws ArgumentException for filesystem-root move
targets; update the assertion to expect ArgumentException by changing the
generic type in AssertInner (used in AssertInvalidMoveTargetPath) from
InvalidOperationException to ArgumentException so the test matches the new guard
behavior in BuildDestinationPath invoked by MoveTargetsMethod.

In `@tests/CodexSessionManager.Storage.Tests/StorageMaintenanceCoverageTests.cs`:
- Around line 12-13: The partial class declaration StorageCoverageExpansionTests
duplicates the [Collection("CurrentDirectorySensitive")] attribute already
present on its other partial, causing CS0579; remove the duplicate attribute
annotation from this partial declaration (delete the
[Collection("CurrentDirectorySensitive")] line so the partial class remains
'public sealed partial class StorageCoverageExpansionTests' without the repeated
attribute).

---

Outside diff comments:
In `@tests/CodexSessionManager.Storage.Tests/StorageCoverageExpansionTests.cs`:
- Around line 54-57: The test currently passes a raw string containing a Windows
path into WriteAssistantSessionAsync which uses string interpolation to build
JSON, causing backslashes to be treated as escapes; instead, serialize the
payload string before passing it to WriteAssistantSessionAsync (e.g., use
JsonSerializer.Serialize or equivalent) so the backslashes are preserved in the
generated JSON; update the call to WriteAssistantSessionAsync to pass the
serialized payload for the message text "see https://example.com and
C:\\repo\\file.txt" so the fixture reflects the intended content.

---

Duplicate comments:
In `@src/CodexSessionManager.App/MainWindow.SessionOperations.cs`:
- Around line 140-156: The code currently calls repository.ListSessionsAsync
with CancellationToken.None and snapshots IsSearchCanceled(searchToken) before
the UI dispatcher hop, allowing stale results to repopulate _sessions; change
ListSessionsAsync to be called with the actual searchToken (not
CancellationToken.None) so the repository work is cancelable, and after the
await re-check the token (e.g. call IsSearchCanceled(searchToken) or
searchToken.ThrowIfCancellationRequested) immediately before modifying _sessions
inside RunOnUiThreadAsync to ensure only the latest, non-canceled search can
update the UI; apply the same fix to the similar block referenced at lines
173-195.

In `@src/CodexSessionManager.Storage/Maintenance/MaintenanceExecutor.cs`:
- Around line 45-53: The logic in ValidateTypedConfirmation is inverted: don't
throw when preview.RequiresTypedConfirmation is false. Change the first guard to
only require non-empty typedConfirmation when RequiresTypedConfirmation is true
(e.g. if (preview.RequiresTypedConfirmation &&
string.IsNullOrWhiteSpace(typedConfirmation)) throw ...). Likewise restrict the
equality check to when RequiresTypedConfirmation is true (e.g. if
(preview.RequiresTypedConfirmation &&
!string.Equals(preview.RequiredTypedConfirmation, typedConfirmation,
StringComparison.Ordinal)) throw ...), so previews that explicitly skip typed
confirmation are allowed.

---

Nitpick comments:
In `@tests/CodexSessionManager.App.Tests/MainWindowMaintenanceCoverageTests.cs`:
- Around line 181-205: These tests launch real system executables
(StartExternalProcess_starts_valid_process and
StartExternalProcess_starts_valid_process_without_arguments) via
StartExternalProcessMethod which makes CI flaky; change the tests to avoid
spawning real system processes by injecting or mocking the process starter seam
used by StartExternalProcessMethod (or refactor StartExternalProcessMethod to
accept an IProcessStarter or delegate), then update the tests to supply a fake
starter that records invocation and returns a successful exit result (or use a
small test helper executable created in test setup) so the tests validate
behavior without depending on cmd.exe/whoami.exe.